<?php

/*
 * This file is part of SwiftMailer. (c) 2004-2009 Chris Corbyn For the full copyright and license information, please view the LICENSE file that was distributed with this source code.
 */

/**
 * Allows reading and writing of bytes to and from an array.
 * 
 * @package Swift
 * @subpackage ByteStream
 * @author Chris Corbyn
 */
class Swift_ByteStream_ArrayByteStream implements Swift_InputByteStream, Swift_OutputByteStream {
	/**
	 * The internal stack of bytes.
	 * 
	 * @var string[]
	 * @access private
	 */
	private $_array = array ();
	
	/**
	 * The size of the stack
	 * 
	 * @var int
	 * @access private
	 */
	private $_arraySize = 0;
	
	/**
	 * The internal pointer offset.
	 * 
	 * @var int
	 * @access private
	 */
	private $_offset = 0;
	
	/**
	 * Bound streams
	 */
	private $_mirrors = array ();
	
	/**
	 * Create a new ArrayByteStream.
	 * If $stack is given the stream will be populated with the bytes it contains.
	 * 
	 * @param mixed $stack
	 *        	of bytes in string or array form, optional
	 */
	public function __construct($stack = null) {
		if (is_array ( $stack )) {
			$this->_array = $stack;
			$this->_arraySize = count ( $stack );
		} elseif (is_string ( $stack )) {
			$this->write ( $stack );
		} else {
			$this->_array = array ();
		}
	}
	
	/**
	 * Reads $length bytes from the stream into a string and moves the pointer
	 * through the stream by $length.
	 * If less bytes exist than are requested the
	 * remaining bytes are given instead. If no bytes are remaining at all, boolean
	 * false is returned.
	 * 
	 * @param int $length        	
	 * @return string
	 */
	public function read($length) {
		if ($this->_offset == $this->_arraySize) {
			return false;
		}
		
		// Don't use array slice
		$end = $length + $this->_offset;
		$end = $this->_arraySize < $end ? $this->_arraySize : $end;
		$ret = '';
		for(; $this->_offset < $end; ++ $this->_offset) {
			$ret .= $this->_array [$this->_offset];
		}
		
		return $ret;
	}
	
	/**
	 * Writes $bytes to the end of the stream.
	 * 
	 * @param string $bytes        	
	 */
	public function write($bytes) {
		$to_add = str_split ( $bytes );
		foreach ( $to_add as $value ) {
			$this->_array [] = $value;
		}
		$this->_arraySize = count ( $this->_array );
		
		foreach ( $this->_mirrors as $stream ) {
			$stream->write ( $bytes );
		}
	}
	
	/**
	 * Not used.
	 */
	public function commit() {
	}
	
	/**
	 * Attach $is to this stream.
	 * The stream acts as an observer, receiving all data that is written.
	 * All {@link write()} and {@link flushBuffers()} operations will be mirrored.
	 *
	 * @param Swift_InputByteStream $is        	
	 */
	public function bind(Swift_InputByteStream $is) {
		$this->_mirrors [] = $is;
	}
	
	/**
	 * Remove an already bound stream.
	 * If $is is not bound, no errors will be raised.
	 * If the stream currently has any buffered data it will be written to $is
	 * before unbinding occurs.
	 *
	 * @param Swift_InputByteStream $is        	
	 */
	public function unbind(Swift_InputByteStream $is) {
		foreach ( $this->_mirrors as $k => $stream ) {
			if ($is === $stream) {
				unset ( $this->_mirrors [$k] );
			}
		}
	}
	
	/**
	 * Move the internal read pointer to $byteOffset in the stream.
	 * 
	 * @param int $byteOffset        	
	 * @return boolean
	 */
	public function setReadPointer($byteOffset) {
		if ($byteOffset > $this->_arraySize) {
			$byteOffset = $this->_arraySize;
		} elseif ($byteOffset < 0) {
			$byteOffset = 0;
		}
		
		$this->_offset = $byteOffset;
	}
	
	/**
	 * Flush the contents of the stream (empty it) and set the internal pointer
	 * to the beginning.
	 */
	public function flushBuffers() {
		$this->_offset = 0;
		$this->_array = array ();
		$this->_arraySize = 0;
		
		foreach ( $this->_mirrors as $stream ) {
			$stream->flushBuffers ();
		}
	}
}
